home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Text⁄Files / Voyeur 1.1.1 / Voyeur ƒ / MSG Shell ƒ / msg prefs.c < prev    next >
Text File  |  1994-02-27  |  9KB  |  398 lines
  1. /**********************************************************************\
  2.  
  3. File:        msg prefs.c
  4.  
  5. Purpose:    This module handles creating/opening/closing/updating
  6.             the preference file, and copying the preference file
  7.             data into application globals (and back).
  8.  
  9.  
  10. Voyeur -- a no-frills file viewer
  11. Copyright ©1993-4, Mark Pilgrim
  12.  
  13. This program is free software; you can redistribute it and/or modify
  14. it under the terms of the GNU General Public License as published by
  15. the Free Software Foundation; either version 2 of the License, or
  16. (at your option) any later version.
  17.  
  18. This program is distributed in the hope that it will be useful,
  19. but WITHOUT ANY WARRANTY; without even the implied warranty of
  20. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21. GNU General Public License for more details.
  22.  
  23. You should have received a copy of the GNU General Public License
  24. along with this program in a file named "GNU General Public License".
  25. If not, write to the Free Software Foundation, 675 Mass Ave,
  26. Cambridge, MA 02139, USA.
  27.  
  28. \**********************************************************************/
  29.  
  30. #include "msg prefs.h"
  31. #include "msg dialogs.h"
  32. #include "msg graphics.h"
  33. #include "msg environment.h"
  34. #include "util.h"
  35. #include "program globals.h"
  36.  
  37. long                gFileID;
  38. Str255                gMyName;
  39. Str255                gMyOrg;
  40. Boolean                gCanSavePrefs;
  41.  
  42. static PrefStruct    thePrefs;
  43. static long            gPrefsFilePos;
  44.  
  45. int PreferencesInit(void)
  46. {
  47.     int            prefsFileID;
  48.     int            err;
  49.     
  50.     gCanSavePrefs=FALSE;
  51.     err=GetFileID();
  52.     if (err!=prefs_allsWell)
  53.         return err;
  54.     
  55.     err=OpenPrefsFile(&prefsFileID);
  56.     if (err!=prefs_allsWell)
  57.     {
  58.         if ((err==prefs_diskReadErr) || (err==prefs_diskWriteErr) || (err==prefs_virginErr))
  59.             ClosePrefsFile(prefsFileID);
  60.         return err;
  61.     }
  62.     
  63.     err=CheckVersion(prefsFileID);
  64.     if (err!=prefs_allsWell)
  65.     {
  66.         ClosePrefsFile(prefsFileID);
  67.         return err;
  68.     }
  69.     
  70.     GetFPos(prefsFileID, &gPrefsFilePos);
  71.     gPrefsFilePos-=sizeof(thePrefs);
  72.     do
  73.     {
  74.         gPrefsFilePos+=sizeof(thePrefs);
  75.         err=GetNextPrefs(prefsFileID);
  76.         if (err==prefs_noMorePrefsErr)
  77.             return (Virgin(prefsFileID));
  78.         
  79.         if (err!=prefs_allsWell)
  80.         {
  81.             ClosePrefsFile(prefsFileID);
  82.             return err;
  83.         }
  84.         
  85.         err=CheckFileID();
  86.     }
  87.     while (err==prefs_IDNotMatchErr);
  88.     
  89.     CopyPrefsToGlobals();
  90.     ClosePrefsFile(prefsFileID);
  91.     
  92.     return prefs_allsWell;
  93. }
  94.  
  95. void PrefsError(int err)
  96. {
  97.     Str255            tempStr;
  98.     
  99.     switch (err)
  100.     {
  101.         case prefs_diskReadErr:
  102.         case prefs_diskWriteErr:
  103.         case prefs_cantCreatePrefsErr:
  104.         case prefs_cantOpenPrefsErr:
  105.         case prefs_versionNotSupportedErr:
  106.             DefaultPrefs();
  107.             gCanSavePrefs=FALSE;
  108.             GetIndString(tempStr, 128, -err);
  109.             ParamText(tempStr, "\p", "\p", "\p");
  110.             PositionDialog('ALRT', prefsErrorAlert);
  111.             StopAlert(prefsErrorAlert, 0L);
  112.             break;
  113.         default:
  114.             gCanSavePrefs=TRUE;
  115. //            if (err!=prefs_virginErr)
  116. //                ShowSplashScreen();
  117.             break;
  118.     }
  119. }
  120.  
  121. int OpenPrefsFile(int *prefsFileID)
  122. {
  123.     int                thisFile;
  124.     OSErr            isHuman;
  125.     int                vRefNum;
  126.     long            dirID;
  127.     FSSpec            prefsFile;
  128.     FInfo            prefsInfo;
  129.     Boolean            newPrefs;
  130.     unsigned char    *name=PREFS_FILE_NAME;
  131.     
  132.     newPrefs=FALSE;
  133.     isHuman=FindFolder(kOnSystemDisk, 'pref', kCreateFolder, &vRefNum, &dirID);
  134.     
  135.     if (isHuman!=noErr)
  136.         return prefs_cantOpenPrefsErr;
  137.     if (gHasFSSpecs)
  138.     {
  139.         isHuman=FSMakeFSSpec(vRefNum, dirID, name, &prefsFile);
  140.         if (isHuman!=noErr)
  141.         {
  142.             if (isHuman==fnfErr)
  143.             {
  144.                 isHuman=FSpCreate(&prefsFile, CREATOR, PREFS_TYPE, 0);
  145.                 if (isHuman!=noErr)
  146.                     return prefs_cantCreatePrefsErr;
  147.                 newPrefs=TRUE;
  148.             }
  149.             else return prefs_cantOpenPrefsErr;
  150.         }
  151.         isHuman=FSpOpenDF(&prefsFile, fsRdWrPerm, &thisFile);
  152.         *prefsFileID=thisFile;
  153.         if (isHuman!=noErr)
  154.             return prefs_cantOpenPrefsErr;
  155.     }
  156.     else
  157.     {
  158.         isHuman=HOpen(vRefNum, dirID, name, fsRdWrPerm, &thisFile);
  159.         *prefsFileID=thisFile;
  160.         if (isHuman!=noErr)
  161.         {
  162.             if (isHuman==fnfErr)
  163.             {
  164.                 isHuman=HCreate(vRefNum, dirID, name, CREATOR, PREFS_TYPE);
  165.                 if (isHuman!=noErr)
  166.                     return prefs_cantCreatePrefsErr;
  167.                 prefsInfo.fdType=PREFS_TYPE;
  168.                 prefsInfo.fdCreator=CREATOR;
  169.                 prefsInfo.fdFlags=0;
  170.                 prefsInfo.fdLocation.h=prefsInfo.fdLocation.v=0;
  171.                 prefsInfo.fdFldr=0;
  172.                 isHuman=HSetFInfo(vRefNum, dirID, name, &prefsInfo);
  173.                 if (isHuman!=noErr)
  174.                     return prefs_cantCreatePrefsErr;
  175.                 isHuman=HOpen(vRefNum, dirID, name, fsRdWrPerm, &thisFile);
  176.                 *prefsFileID=thisFile;
  177.                 if (isHuman!=noErr)
  178.                     return prefs_cantOpenPrefsErr;
  179.                 newPrefs=TRUE;
  180.             }
  181.             else return prefs_cantOpenPrefsErr;
  182.         }
  183.     }
  184.     if (newPrefs)
  185.         return SetupNewPrefsFile(*prefsFileID);
  186.     
  187.     return prefs_allsWell;
  188. }
  189.  
  190. int SetupNewPrefsFile(int prefsFileID)
  191. {
  192.     int                err;
  193.     OSErr            isHuman;
  194.     long            count;
  195.     int                temp;
  196.     
  197.     gPrefsFilePos=2L;
  198.     isHuman=SetEOF(prefsFileID, 2L);
  199.     if (isHuman!=noErr)
  200.         return prefs_diskWriteErr;
  201.     SetFPos(prefsFileID, 1, 0L);
  202.     temp=PREFS_HEADER_VERSION;
  203.     count=2L;
  204.     isHuman=FSWrite(prefsFileID, &count, &temp);
  205.     if (isHuman!=noErr)
  206.         return prefs_diskWriteErr;        
  207.     err=Virgin(prefsFileID);
  208.     return err;
  209. }
  210.  
  211. void ClosePrefsFile(int prefsFileID)
  212. {
  213.     FSClose(prefsFileID);
  214.     FlushVol(0L, kOnSystemDisk);
  215. }
  216.  
  217. int GetNextPrefs(int prefsFileID)
  218. {
  219.     OSErr        isHuman;
  220.     long        count;
  221.     
  222.     count=sizeof(thePrefs);
  223.     isHuman=FSRead(prefsFileID, &count, &thePrefs);
  224.     if (isHuman==eofErr)
  225.         return prefs_noMorePrefsErr;
  226.     if (isHuman!=noErr)
  227.         return prefs_diskReadErr;
  228.     
  229.     return prefs_allsWell;
  230. }
  231.  
  232. int SavePrefs(int prefsFileID)
  233. {
  234.     long        oldEOF;
  235.     OSErr        isHuman;
  236.     long        count;
  237.     
  238.     GetEOF(prefsFileID, &oldEOF);
  239.     if (gPrefsFilePos>=oldEOF)
  240.     {
  241.         isHuman=SetEOF(prefsFileID, oldEOF+sizeof(thePrefs));
  242.         if (isHuman!=noErr)
  243.             return prefs_diskWriteErr;
  244.     }
  245.     SetFPos(prefsFileID, 1, gPrefsFilePos);
  246.     count=sizeof(thePrefs);
  247.     isHuman=FSWrite(prefsFileID, &count, &thePrefs);
  248.     if (isHuman!=noErr)
  249.         return prefs_diskWriteErr;
  250.     
  251.     return prefs_allsWell;
  252. }
  253.  
  254. int CheckVersion(int prefsFileID)
  255. {
  256.     OSErr        isHuman;
  257.     long        count;
  258.     int            temp;
  259.     
  260.     count=2L;
  261.     isHuman=FSRead(prefsFileID, &count, &temp);
  262.     if (isHuman!=noErr)
  263.         return prefs_diskReadErr;
  264.     if (temp>PREFS_HEADER_VERSION)
  265.         return prefs_versionNotSupportedErr;
  266.     if (temp<PREFS_HEADER_VERSION)
  267.         return SetupNewPrefsFile(prefsFileID);
  268.     
  269.     return prefs_allsWell;
  270. }
  271.  
  272. int GetFileID(void)
  273. {
  274.     CInfoPBRec        pb;
  275.     int                err;
  276.     
  277.     pb.hFileInfo.ioCompletion=0L;
  278.     pb.hFileInfo.ioNamePtr=CurApName;
  279.     pb.hFileInfo.ioVRefNum=0;
  280.     pb.hFileInfo.ioFDirIndex=0;
  281.     pb.hFileInfo.ioDirID=0;
  282.     err=PBGetCatInfo(&pb, FALSE);
  283.     if (err!=noErr)
  284.         return prefs_diskReadErr;
  285.     
  286.     gFileID=pb.hFileInfo.ioDirID;
  287.     
  288.     return prefs_allsWell;
  289. }
  290.  
  291. int CheckFileID(void)
  292. {
  293.     return (thePrefs.fileID==gFileID) ? prefs_allsWell : prefs_IDNotMatchErr;
  294. }
  295.  
  296. int Virgin(int prefsFileID)
  297. {
  298.     int            err;
  299.     
  300.     DefaultPrefs();
  301.     CopyGlobalsToPrefs();
  302.     err=SavePrefs(prefsFileID);
  303.     if (err!=prefs_allsWell)
  304.         return err;
  305.     GetRegistration();
  306.     CopyGlobalsToPrefs();
  307.     err=SavePrefs(prefsFileID);
  308.     
  309.     return (err==prefs_allsWell) ? prefs_virginErr : err;
  310. }
  311.  
  312. void DefaultPrefs(void)
  313. {
  314.     gMyName[0]=0x03;
  315.     gMyName[1]='B';
  316.     gMyName[2]='o';
  317.     gMyName[3]='b';
  318.     gMyOrg[0]=gFindString[0]=gFindHexString[0]=0x00;
  319. }
  320.  
  321. void CopyGlobalsToPrefs(void)
  322. {
  323.     Mymemset(&thePrefs, 0, sizeof(thePrefs));
  324.     if (gMyName[0]>0x27)
  325.         gMyName[0]=0x27;
  326.     if (gMyOrg[0]>0x27)
  327.         gMyOrg[0]=0x27;
  328.     Mymemcpy(thePrefs.regname, gMyName, gMyName[0]+1);
  329.     Mymemcpy(thePrefs.regorg, gMyOrg, gMyOrg[0]+1);
  330.     Mymemcpy(thePrefs.findstring, gFindString, 256);
  331.     Mymemcpy(thePrefs.findhexstring, gFindHexString, 256);
  332.     thePrefs.fileID=gFileID;
  333. }
  334.  
  335. void CopyPrefsToGlobals(void)
  336. {
  337.     Mymemcpy(gMyName, thePrefs.regname, thePrefs.regname[0]+1);
  338.     Mymemcpy(gMyOrg, thePrefs.regorg, thePrefs.regorg[0]+1);
  339.     Mymemcpy(gFindString, thePrefs.findstring, 256);
  340.     Mymemcpy(gFindHexString, thePrefs.findhexstring, 256);
  341. }
  342.  
  343. void GetRegistration(void)
  344. {
  345.     DialogPtr        theDlog;
  346.     int                itemSelected = 0;
  347.     int                newleft;
  348.     int                newtop;
  349.     int                itemType;
  350.     Handle            item;
  351.     Rect            box;
  352.     
  353.     theDlog = GetNewDialog(personalDialog, 0L, (WindowPtr)-1L);
  354.     newleft = gMainScreenBounds.left + (((gMainScreenBounds.right -
  355.                 gMainScreenBounds.left) - (theDlog->portRect.right -
  356.                 theDlog->portRect.left)) / 2);
  357.     newtop = gMainScreenBounds.top + (((gMainScreenBounds.bottom -
  358.                 gMainScreenBounds.top) - (theDlog->portRect.bottom -
  359.                 theDlog->portRect.top)) / 2);
  360.     if(newtop < 15)
  361.         newtop = 15;
  362.     GetDItem(theDlog, 1, &itemType, &item, &box);
  363.     InsetRect(&box, -4, -4);
  364.     SetDItem(theDlog, 8, userItem, OutlineDefaultButton, &box);
  365.     ParamText(APPLICATION_NAME, "\p", "\p", "\p");
  366.     
  367.     MoveWindow(theDlog, newleft, newtop, TRUE);
  368.     ShowWindow(theDlog);
  369.     while(itemSelected != 1)
  370.     {
  371.         ModalDialog(0L, &itemSelected);
  372.     }
  373.     GetDItem(theDlog,4,&itemType,&item,&box);
  374.     GetIText(item,&gMyName);
  375.     
  376.     GetDItem(theDlog,5,&itemType,&item,&box);
  377.     GetIText(item,&gMyOrg);
  378.  
  379.     if (gMyName[0]==0x00)
  380.         DefaultPrefs();
  381.  
  382.     HideWindow(theDlog);
  383.     DisposeDialog(theDlog);
  384. }
  385.  
  386. void SaveThePrefs(void)
  387. {
  388.     int            prefsFileID;
  389.     
  390.     if (gCanSavePrefs)
  391.     {
  392.         OpenPrefsFile(&prefsFileID);
  393.         CopyGlobalsToPrefs();
  394.         SavePrefs(prefsFileID);
  395.         ClosePrefsFile(prefsFileID);
  396.     }
  397. }
  398.